package com.pancm.utils;

import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.codec.binary.Base64;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

/**
 * 
 * @Title: MyTools
 * @Description:常用工具类
 * @Version:1.0.1
 * @author pancm
 * @date 2017年9月26日
 */
public final class MyTools {
	/** 时间格式包含毫秒 */
	private static final String sdfm = "yyyy-MM-dd HH:mm:ss SSS";
	/** 普通的时间格式 */
	private static final String sdf = "yyyy-MM-dd HH:mm:ss";
	/** 时间戳格式 */
	private static final String sd = "yyyyMMddHHmmss";
	/** 检查是否为整型 */
	private static Pattern p = Pattern.compile("^\\d+$");

	/**
	 * 判断String类型的数据是否为空 null,""," " 为true "A"为false
	 * 
	 * @return boolean
	 */
	public static boolean isEmpty(String str) {
		return (null == str || str.trim().length() == 0);
	}

	/**
	 * 判断String类型的数据是否为空 null,"", " " 为false "A", 为true
	 * 
	 * @return boolean
	 */
	public static boolean isNotEmpty(String str) {
		return !isEmpty(str);
	}

	/**
	 * 判断list类型的数据是否为空 null,[] 为 true
	 * 
	 * @return boolean
	 */
	public static boolean isEmpty(List<?> list) {
		return (null == list || list.size() == 0);
	}

	/**
	 * 判断list类型的数据是否为空 null,[] 为 false
	 * 
	 * @return boolean
	 */
	public static boolean isNotEmpty(List<?> list) {
		return !isEmpty(list);
	}

	/**
	 * 判断Map类型的数据是否为空 null,[] 为true
	 * 
	 * @return boolean
	 */
	public static boolean isEmpty(Map<?, ?> map) {
		return (null == map || map.size() == 0);
	}

	/**
	 * 判断map类型的数据是否为空 null,[] 为 false
	 * 
	 * @return boolean
	 */
	public static boolean isNotEmpty(Map<?, ?> map) {
		return !isEmpty(map);
	}

	/**
	 * 判断JSONObject类型的数据是否为空 null,[] 为true
	 * 
	 * @return boolean
	 */
	public static boolean isEmpty(JSONObject json) {
		return (null == json || json.size() == 0);
	}

	/**
	 * 判断json类型的数据是否为空 null,[] 为 false
	 * 
	 * @return boolean
	 */
	public static boolean isNotEmpty(JSONObject json) {
		return !isEmpty(json);
	}

	/**
	 * 字符串反转 如:入参为abc，出参则为cba
	 * 
	 * @param str
	 * @return
	 */
	public static String reverse(String str) {
		if (isEmpty(str)) {
			return str;
		}
		return reverse(str.substring(1)) + str.charAt(0);
	}

	/**
	 * 获取当前long类型的的时间
	 * 
	 * @return long
	 */
	public static long getNowLongTime() {
		return System.currentTimeMillis();
	}

	/**
	 * long类型的时间转换成 yyyyMMddHHmmss String类型的时间
	 * 
	 * @param lo
	 *            long类型的时间
	 * @return
	 */
	public static String longTime2StringTime(long lo) {
		return longTime2StringTime(lo, sd);
	}

	/**
	 * long类型的时间转换成自定义时间格式
	 * 
	 * @param lo
	 *            long类型的时间
	 * @param format
	 *            时间格式
	 * @return String
	 */
	public static String longTime2StringTime(long lo, String format) {
		return new SimpleDateFormat(format).format(lo);
	}

	/**
	 * String类型的时间转换成 long
	 * 
	 * @param lo
	 * @return String
	 * @throws ParseException
	 */
	public static long stringTime2LongTime(String time, String format) throws ParseException {
		if (isEmpty(format)) {
			format = sdf;
		}
		if (isEmpty(time)) {
			time = getNowTime(format);
		}
		SimpleDateFormat sd = new SimpleDateFormat(format);
		Date date = sd.parse(time);
		return date.getTime();
	}

	/**
	 * 格式化时间
	 * 
	 * @param format1
	 *            之前的 时间格式
	 * @param format2
	 *            之后的 时间格式
	 * @param time
	 *            时间
	 * @return String
	 * @throws ParseException
	 */
	public static String formatTime(String format1, String format2, String time) throws ParseException {
		SimpleDateFormat d1 = new SimpleDateFormat(format1);
		SimpleDateFormat d2 = new SimpleDateFormat(format2);
		time = d2.format(d1.parse(time));
		return time;
	}

	/**
	 * 时间补全 例如将2018-04-04补全为2018-04-04 00:00:00.000
	 * 
	 * @param time
	 *            补全的时间
	 * @return
	 */
	public static String complementTime(String time) {
		return complementTime(time, sdfm, 1);

	}

	/**
	 * 时间补全 例如将2018-04-04补全为2018-04-04 00:00:00.000
	 * 
	 * @param time
	 *            补全的时间
	 * @param format
	 *            补全的格式
	 * @param type
	 *            类型 1:起始;2:终止
	 * @return
	 */
	public static String complementTime(String time, String format, int type) {
		if (isEmpty(time) || isEmpty(format)) {
			return null;
		}
		int tlen = time.length();
		int flen = format.length();
		int clen = flen - tlen;
		if (clen <= 0) {
			return time;
		}
		StringBuffer sb = new StringBuffer(time);
		if (clen == 4) {
			if (type == 1) {
				sb.append(".000");
			} else {
				sb.append(".999");
			}
		} else if (clen == 9) {
			if (type == 1) {
				sb.append(" 00:00:00");
			} else {
				sb.append(" 23:59:59");
			}
		} else if (clen == 13) {
			if (type == 1) {
				sb.append(" 00:00:00.000");
			} else {
				sb.append(" 23:59:59.999");
			}
		}
		return sb.toString();

	}

	/**
	 * 获取当前String类型的的时间 使用默认格式 yyyy-MM-dd HH:mm:ss
	 * 
	 * @return String
	 */
	public static String getNowTime() {
		return getNowTime(sdf);
	}

	/**
	 * 获取当前String类型的的时间(自定义格式)
	 * 
	 * @param format
	 *            时间格式
	 * @return String
	 */
	public static String getNowTime(String format) {
		return new SimpleDateFormat(format).format(new Date());
	}

	/**
	 * 获取当前Timestamp类型的的时间
	 * 
	 * @return Timestamp
	 */
	public static Timestamp getTNowTime() {
		return new Timestamp(getNowLongTime());
	}

	/**
	 * 获取的String类型的当前时间并更改时间
	 * 
	 * @param number
	 *            要更改的的数值
	 * @param format
	 *            更改时间的格式 如yyyy-MM-dd HH:mm:ss
	 * @param type
	 *            更改时间的类型 时:h; 分:m ;秒:s
	 * @return String
	 */
	public static String changeTime(int number, String format, String type) {
		return changeTime(number, format, type, "");
	}

	/**
	 * 获取的String类型时间并更改时间
	 * 
	 * @param number
	 *            要更改的的数值
	 * @param format
	 *            更改时间的格式
	 * @param type
	 *            更改时间的类型 。时:h; 分:m ;秒:s
	 * @param time
	 *            更改的时间 没有则取当前时间
	 * @return String
	 */
	public static String changeTime(int number, String format, String type, String time) {
		if (isEmpty(time)) { // 如果没有设置时间则取当前时间
			time = getNowTime(format);
		}
		SimpleDateFormat format1 = new SimpleDateFormat(format);
		Date d = null;
		Calendar ca = null;
		String backTime = null;
		try {
			d = format1.parse(time);
			ca = Calendar.getInstance(); // 定义一个Calendar 对象
			ca.setTime(d);// 设置时间
			if ("h".equals(type)) {
				ca.add(Calendar.HOUR, number);// 改变时
			} else if ("m".equals(type)) {
				ca.add(Calendar.MINUTE, number);// 改变分
			} else if ("s".equals(type)) {
				ca.add(Calendar.SECOND, number);// 改变秒
			}
			backTime = format1.format(ca.getTime()); // 转化为String 的格式
		} catch (Exception e) {
			e.printStackTrace();
		}
		return backTime;
	}

	/**
	 * 两个日期带时间比较 第二个时间大于第一个则为true，否则为false
	 * 
	 * @param String
	 * @return boolean
	 * @throws ParseException
	 */
	public static boolean isCompareDay(String time1, String time2, String format) {
		if (isEmpty(format)) {// 如果没有设置格式使用默认格式
			format = sdf;
		}
		SimpleDateFormat s1 = new SimpleDateFormat(format);
		Date t1 = null;
		Date t2 = null;
		try {
			t1 = s1.parse(time1);
			t2 = s1.parse(time2);
			return t2.after(t1);// 当 t2 大于 t1 时，为 true，否则为 false
		} catch (ParseException e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 获取几天之前的时间
	 * 
	 * @since 1.8
	 * @param day
	 * @return
	 */
	public static String getMinusDays(int day) {
		return getMinusDays(day, sdf);
	}

	/**
	 * 获取几天之前的时间
	 * 
	 * @since 1.8
	 * @param day
	 * @param format
	 * @return
	 */
	public static String getMinusDays(int day, String format) {
		return LocalDateTime.now().minusDays(day).format(DateTimeFormatter.ofPattern(format));
	}

	/**
	 * 获取几天之后的时间
	 * 
	 * @since 1.8
	 * @param day
	 * @return
	 */
	public static String getPlusDays(int day) {
		return getPlusDays(day, sdf);
	}

	/**
	 * 获取几天之后的时间
	 * 
	 * @since 1.8
	 * @param day
	 * @param format
	 * @return
	 */
	public static String getPlusDays(int day, String format) {
		return LocalDateTime.now().plusDays(day).format(DateTimeFormatter.ofPattern(format));
	}

	/**
	 * 获取几天之后的时间
	 * 
	 * @since 1.8
	 * @param day
	 * @return
	 */
	public static String getPlusMonths(int month) {
		return getPlusMonths(month, sdf);
	}

	/**
	 * 获取几月之后的时间
	 * 
	 * @since 1.8
	 * @param day
	 * @param format
	 * @return
	 */
	public static String getPlusMonths(int month, String format) {
		return LocalDateTime.now().plusMonths(month).format(DateTimeFormatter.ofPattern(format));
	}

	/**
	 * 增加月份
	 * 
	 * @param time
	 *            格式为yyyy-MM-dd
	 * @param month
	 *            增加月份
	 * @return
	 */
	public static String addPlusMonths(String time, int month) {
		return LocalDate.parse(time).plusMonths(month).toString();
	}

	/**
	 * 时间相比得月份 如果是201711和201801相比，返回的结果是2 前面的时间要小于后面的时间
	 * 
	 * @param month
	 *            格式为yyyyMM
	 * @param toMonth
	 *            格式为yyyyMM
	 * @since jdk 1.8
	 * @return
	 */
	public static int diffMonth(String month, String toMonth) {
		int year1 = Integer.parseInt(month.substring(0, 4));
		int month1 = Integer.parseInt(month.substring(4, 6));
		int year2 = Integer.parseInt(month.substring(0, 4));
		int month2 = Integer.parseInt(month.substring(4, 6));
		LocalDate ld1 = LocalDate.of(year1, month1, 01);
		LocalDate ld2 = LocalDate.of(year2, month2, 01);
		return Period.between(ld1, ld2).getMonths();
	}

	/**
	 * 判断是否为整型
	 * 
	 * @param String
	 * @return boolean
	 */
	public static boolean isInteger(String str) {
		Matcher m = p.matcher(str);
		return m.find();
	}

	/**
	 * 自定义位数产生随机数字
	 * 
	 * @param int
	 * @return String
	 */
	public static String random(int count) {
		char start = '0';
		char end = '9';
		Random rnd = new Random();
		char[] result = new char[count];
		int len = end - start + 1;
		while (count-- > 0) {
			result[count] = (char) (rnd.nextInt(len) + start);
		}
		return new String(result);
	}

	/**
	 * 获取自定义长度的随机数(含字母)
	 * 
	 * @param len
	 *            长度
	 * @return String
	 */
	public static String random2(int len) {
		int random = Integer.parseInt(random(5));
		Random rd = new Random(random);
		final int maxNum = 62;
		StringBuffer sb = new StringBuffer();
		int rdGet;// 取得随机数
		char[] str = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
				't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
				'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8',
				'9' };
		int count = 0;
		while (count < len) {
			rdGet = Math.abs(rd.nextInt(maxNum));// 生成的数最大为62-1
			if (rdGet >= 0 && rdGet < str.length) {
				sb.append(str[rdGet]);
				count++;
			}
		}
		return sb.toString();
	}

	/**
	 * 获取本机ip
	 * 
	 * @return String
	 * @throws UnknownHostException
	 */
	public static String getLocalHostIp() throws UnknownHostException {
		return InetAddress.getLocalHost().getHostAddress();
	}

	/**
	 * Object 转换为 String
	 * 
	 * @param list
	 * @return String
	 */
	public static String toString(Object obj) {
		return JSON.toJSONString(obj);
	}

	/**
	 * JSON 转换为 JavaBean
	 * 
	 * @param json
	 * @param t
	 * @return <T>
	 */
	public static <T> T toBean(JSONObject json, Class<T> t) {
		return JSON.toJavaObject(json, t);
	}

	/**
	 * JSON 字符串转换为 JavaBean
	 * 
	 * @param str
	 * @param t
	 * @return <T>
	 */
	public static <T> T toBean(String str, Class<T> t) {
		return JSON.parseObject(str, t);
	}

	/**
	 * JSON 字符串 转换成JSON格式
	 * 
	 * @param obj
	 * @return JSONObject
	 */
	public static JSONObject toJson(String str) {
		if (isEmpty(str)) {
			return new JSONObject();
		}
		return JSON.parseObject(str);

	}

	/**
	 * JavaBean 转化为JSON
	 * 
	 * @param t
	 * @return
	 */
	public static JSONObject toJson(Object t) {
		if (null == t || "".equals(t)) {
			return new JSONObject();
		}
		return (JSONObject) JSON.toJSON(t);
	}

	/**
	 * JSON 字符串转换为 HashMap
	 * 
	 * @param json
	 *            - String
	 * @return Map
	 */
	@SuppressWarnings("rawtypes")
	public static Map toMap(String json) {
		if (isEmpty(json)) {
			return new HashMap();
		}
		return JSON.parseObject(json, HashMap.class);
	}

	/**
	 * 将map转化为string
	 * 
	 * @param m
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static String toString(Map m) {
		return JSONObject.toJSONString(m);
	}

	/**
	 * String转换为数组
	 * 
	 * @param text
	 * @return
	 */
	public static <T> Object[] toArray(String text) {
		return toArray(text, null);
	}

	/**
	 * String转换为数组
	 * 
	 * @param text
	 * @return
	 */
	public static <T> Object[] toArray(String text, Class<T> clazz) {
		return JSON.parseArray(text, clazz).toArray();
	}

	/**
	 * name1=value1&name2=value2格式的数据转换成json数据格式
	 * 
	 * @param str
	 * @return
	 */
	public static JSONObject str2Json(String str) {
		if (isEmpty(str)) {
			return new JSONObject();
		}
		JSONObject json = new JSONObject();
		String[] str1 = str.split("&");
		String str3 = "", str4 = "";
		if (null == str1 || str1.length == 0) {
			return new JSONObject();
		}
		for (String str2 : str1) {
			str3 = str2.substring(0, str2.lastIndexOf("="));
			str4 = str2.substring(str2.lastIndexOf("=") + 1, str2.length());
			json.put(str3, str4);
		}
		return json;
	}

	/**
	 * json数据格式 转换成name1=value1&name2=value2格式
	 * 
	 * @param str
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static String json2Str(JSONObject json) {
		if (isEmpty(json)) {
			return null;
		}
		StringBuffer sb = new StringBuffer();
		Iterator it = json.entrySet().iterator(); // 定义迭代器
		while (it.hasNext()) {
			Map.Entry er = (Entry) it.next();
			sb.append(er.getKey());
			sb.append("=");
			sb.append(er.getValue());
			sb.append("&");
		}
		sb.delete(sb.length() - 1, sb.length()); // 去掉最后的&
		return sb.toString();
	}

	/**
	 * 将JDBC查询的数据转换成List类型
	 * 
	 * @param ResultSet
	 * @return List
	 * @throws SQLException
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static List convertList(ResultSet rs) throws SQLException {
		if (null == rs) {
			return new ArrayList<>();
		}
		List list = new ArrayList();
		ResultSetMetaData md = rs.getMetaData();
		int columnCount = md.getColumnCount();
		while (rs.next()) {
			JSONObject rowData = new JSONObject();
			for (int i = 1; i <= columnCount; i++) {
				rowData.put(md.getColumnName(i), rs.getObject(i));
			}
			list.add(rowData);
		}
		return list;
	}

	/**
	 * MD5加密
	 * 
	 * @param message
	 * @return
	 */
	public static String md5Encode(String message) {
		byte[] secretBytes = null;
		try {
			secretBytes = MessageDigest.getInstance("md5").digest(message.getBytes());
		} catch (NoSuchAlgorithmException e) {
			throw new RuntimeException("没有md5这个算法！");
		}
		String md5code = new BigInteger(1, secretBytes).toString(16);// 16进制数字
		// 如果生成数字未满32位，需要前面补0
		int length = 32 - md5code.length();
		for (int i = 0; i < length; i++) {
			md5code = "0" + md5code;
		}
		return md5code;
	}

	/**
	 * base64 加密
	 * 
	 * @param str
	 * @return
	 */
	public static String base64En(String str) {
		Base64 base64 = new Base64();
		byte[] encode = base64.encode(str.getBytes());
		return new String(encode);
	}

	/**
	 * base64解密
	 * 
	 * @param encodeStr
	 * @return
	 */
	@SuppressWarnings("static-access")
	public static String base64De(String encodeStr) {
		Base64 base64 = new Base64();
		byte[] decodeStr = base64.decodeBase64(encodeStr);
		return new String(decodeStr);
	}

	/**
	 * 十进制转二进制
	 * 
	 * @param n
	 * @return
	 */
	public static String decToBinary(int n) {
		String str = "";
		while (n != 0) {
			str = n % 2 + str;
			n = n / 2;
		}
		return str;
	}

	/**
	 * 二进制转十进制
	 * 
	 * @param n
	 * @return
	 */
	public static int binaryToDec(char[] cs) {
		return binaryToDec(cs);
	}

	/**
	 * 二进制转十进制
	 * 
	 * @param n
	 * @return
	 */
	public static int binaryToDec(String cs) {
		return new BigInteger(new String(cs), 2).intValue();
	}

	/**
	 * 本方法的测试示例
	 * 
	 * @param args
	 */
	@SuppressWarnings({ "rawtypes" })
	public static void main(String[] args) {
		/*
		 * String 和List 空数据判断
		 */
		String str1 = "";
		String str2 = " ";
		String str3 = null;
		String str4 = "a";
		List list = null;
		List<String> list2 = new ArrayList<String>();
		List<Object> list3 = new ArrayList<Object>();
		list3.add("a");

		System.out.println("str1 :" + isEmpty(str1)); // str1 :true
		System.out.println("str2 :" + isEmpty(str2)); // str2 :true
		System.out.println("str3 :" + isEmpty(str3)); // str3 :true
		System.out.println("str4 :" + isEmpty(str4)); // str4 :false
		System.out.println("list :" + isEmpty(list)); // list :true
		System.out.println("list2 :" + isEmpty(list2)); // list2 :true
		System.out.println("list3 :" + isEmpty(list3)); // list3 :false

		/*
		 * 时间
		 */
		long start = getNowLongTime();
		System.out.println("getNowTime():" + getNowTime()); // getNowTime():2017-09-26
															// 17:46:44
		System.out.println("getNowLongTime():" + getNowLongTime()); // getNowLongTime():1506419204920
		System.out.println("getNowTime(sdfm):" + getNowTime(sdfm)); // getNowTime(sdfm):2017-09-26
																	// 17:46:44
																	// 920
		System.out.println("当时时间向前推移30秒:" + changeTime(-30, sdf, "s")); // 2017-09-26
																		// 17:46:14
		System.out.println("时间比较:" + isCompareDay(getNowTime(sdfm), changeTime(-30, sdf, "s"), "")); // 时间比较:false
		System.out.println("getTNowTime():" + getTNowTime()); // getTNowTime():2017-09-26
																// 17:46:44.921
		System.out.println("LongTime2StringTime():" + longTime2StringTime(start, sd)); // LongTime2StringTime():20170926174644

		/*
		 * 整型判断
		 */
		String st = "258369";
		String st2 = "258369A!@";
		String st3 = "258  369 ";
		System.out.println("st:" + isInteger(st)); // st:true
		System.out.println("st2:" + isInteger(st2)); // st2:false
		System.out.println("st3:" + isInteger(st3)); // st3:false

		/*
		 * 字符串反转
		 */
		String re = "abcdefg";
		System.out.println("字符串反转:" + reverse(re)); // 字符串反转:gfedcba

		/*
		 * 本机IP
		 */
		try {
			System.out.println("本机IP:" + getLocalHostIp()); // 本机IP:192.168.1.111
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}

		/*
		 * 随机数
		 */

		System.out.println("6位随机数:" + random(6)); // 6位随机数:222488
		System.out.println("10位随机数:" + random2(10)); // 10位随机数:ZwW0pmofjW

		/*
		 * JSON数据转换
		 */

		String value = "name1=value1&name2=value2&name3=value3";
		JSONObject json = new JSONObject();
		json.put("name1", "value1");
		json.put("name2", "value2");
		json.put("name3", "value3");
		System.out.println("value:" + value); // value:name1=value1&name2=value2&name3=value3
		System.out.println("str2Json:" + str2Json(value)); // str2Json:{"name1":"value1","name2":"value2","name3":"value3"}
		System.out.println("json:" + json.toJSONString()); // json:{"name1":"value1","name2":"value2","name3":"value3"}
		System.out.println("json2Str:" + json2Str(json)); // json2Str:name3=value3&name1=value1&name2=value2

		String jsonString = json.toJSONString();
		System.out.println("jsonString:" + jsonString); // {"name1":"value1","name2":"value2","name3":"value3"}
		System.out.println("toJson(jsonString):" + toJson(jsonString)); // toJson(jsonString):{"name1":"value1","name2":"value2","name3":"value3"}

		System.out.println("long TO String" + longTime2StringTime(32472115200L));
		System.out.println("long TO String" + longTime2StringTime(1513330097L));

		String time1 = "2018-04-04";
		String time2 = "2018-04-04 14:48:00";
		String time3 = "2018-04-04 14:48:00.000";
		System.out.println("时间补全:" + complementTime(time1, sdfm, 1));
		System.out.println("时间补全:" + complementTime(time2, sdfm, 2));
		System.out.println("时间补全:" + complementTime(time3, sdfm, 1));
		String time4 = addPlusMonths(time1, 2);
		System.out.println("增加之前的数据:" + time1 + "增加月份之后的数据:" + time4);
		System.out.println("相差月份:" + diffMonth("201711", "201801"));



		int l = 2;
		String string = "10101";
		System.out.println(l + " 十进制转二进制: " + decToBinary(l));

		System.out.println(string + " 二进制转十进制: " + binaryToDec(string));

	}

}
